Panels 
In diesem Tutorial werde ich Ihnen zeigen, wie einfach es ist Panels in ihrem Spiel einzubauen. Nehmen wir mal an, Sie wollen ein Start-Panel erzeugen, was 2 Sekunden vor dem Start kommt. Alles, was wir dazu brauchen ist ein Startbild und das passende Script. Fangen wir mit dem Bild an. Sie knnen es mit einem Belibigen Malprogramm machen, z.B. Picture Publisher, Photo Shop oder sonst was. Wenn Sie es fertig gemalt haben Spiechern Sie es als "start_pic.pcx" ab. Jetzt fehlt uns nur noch ein passendes Skript dazu. Das Script sieht vollgendermaen aus: 


--------------------------------------------------------------------------------
bmap start_map = "start_pic.pcx"; 
panel start_pan 
{ 
pos_x=0; 
pos_y=0; 
bmap = start_map; 
flags = d3d; 
} 
--------------------------------------------------------------------------------

So, jetzt werden wir erstmal die befehle unter die Lupe nehmen. 
Panel Name 
Mit dem Schlsselwort Panel teilen Sie dem Compiler mit, dass nun eine Definierung eines Panels folgt. Natrlich mssen Sie nicht "Panel Name" schreiben, sondern nur "Panel" und dann einen Namen, mit dem Sie auf das Panel zugreifen knnen. Dann folgt eine geschweifte Klammer "{", die zeigt ,dass die Definition des Panels beginnt. 

pos_x=var 
Mit "pos_x=var" geben Sie die X-Position des Panels an. Auch hier drfen Sie nicht "var" schreiben, sondern eine Zahl (var = variable = Zahl). 

pos_y=var 
Mit "pos_y=var" geben Sie die Y-Position des Panels an. Auch hier drfen Sie nicht "var" schreiben, sondern eine Zahl (var = variable = Zahl). 

bmap = bmap 
Damit geben Sie das Bild an, dass das Panel anzeigen soll. In unserem Fall start_map, dass wir oberhalb von Panel mit der Zeile "bmap start_map = "start_pic.pcx";" Definiert haben. 

flags = flags 
Damit knnen Sie verschiedene Eigenschaften des Panels Festlegen. Z.b. "transparent", "visible"(fr sichtbar),.... 

Zum Schluss folgt wieder eine Geschweifte Kalmmer "}". Wenn Sie das Script schon ausprobiert haben, werden Sie merken, dass nicht passiert. dass liegt daran, dass wir bei der Defination des Panels das Flag "visible" nicht genommen haben. Warum? Wir mchten das Panel schlielich nicht die ganze Zeit, sondern nur 2 Sekunden anziegen. Dazu schreiben wir jetzt einfach noch eine function, die wenn man sie aufruft das Panel erscheinen lsst, 2 Sekunden wartet und das Panel wieder verschwinden lsst. Das sieht dann folgendermaen aus: 


--------------------------------------------------------------------------------
function show_start_pan() 
{ 
start_pan.visible = on; 
waitt(32); 
start_pan.visible = off; 
} 
--------------------------------------------------------------------------------

Sie sehen, dass die function nicht schwer ist. als erstes wird das "visible-Flag" des Panels start_pan eingeschaltet. Dann wird 32 Ticks gewartet. Eine Sekunde besteht aus 16-Ticks. Achten Sie darauf, dass Sie waitt mit 2 t schreiben, sonst wird 32-Frames gewartet - und das sind nicht 2 Sekunden! Aber wenn Sie jetzt alles starten, wird immer noch nichts passieren! Das liegt daran, dass nichts die Function show_start_pan() ausfhrt. Dies ist aber schnell mit einer Zeile in der main function, die als erstes aufgerufen wird, geschenen! 
--------------------------------------------------------------------------------
function main() 
{ 
//.....Quelcode.... 
//Aufruf unserer function: 
show_start_pan(); 
} 
--------------------------------------------------------------------------------

So, nachdem Sie das alles in ihrer Datei geschrieben haben, msste beim Start ihr gemaltes Bild fr ca. 2 Seckunden angezeigt werden. wenn nicht schicken sie mir eine Email. 
So, das war's schon. Ich hoffe ich konnte Ihnen damit helfen. 
Copyright(c) by Thomas Kalkschmidt 


Player-Actionen 
In diesem Tutorial werde ich Ihnen zeigen, wie man eine eigene Player Action macht - ganz ohne Templates! Fangen wir mal an! Als erstes bentigen wir die Action, der wir der Entity nachher zuweisen: 


--------------------------------------------------------------------------------
action player1 
{ 
} 
--------------------------------------------------------------------------------

So, dass bringt aber nichts, weil die Action ja auch was machen muss! Um den Player in die Richtungen zu Bewegen, mssen wir den Befehl move benutzten! Mit dem knnen wir die Entity steuern. 


--------------------------------------------------------------------------------
var dist[3]; 
action player1 
{ 
while(1) 
{ 
dist.x = key_force.x * 10; 
dist.y = 0; 
dist.z = 0; 
move(my,dist,nullvector); 
wait(1); 
} 
} 
--------------------------------------------------------------------------------

So, hier komt am Anfang erstmal eine Schleife - der player soll sich ja immer bewegen knnen. Mit dem Vector dist, den wir ber der Action definiert haben, knnen wir jetzt die Geschwindigkeiten in die Richtungen angeben. Dabei muss darauf geachtet werden, dass der Player nicht immer nach vorne geht, sondern nur wenn man die Pfeil Taste nach oben drckt. Die Variasble key_force.x gibt an, ob eine der Pfeiltasten nach oben oder unten gedrckt wurde! Etwa so: 


key_force.x = 0; / es wurde nicht die Pfeil Taste n. oben oder unten gedrckt 
key_force.x = 1; / es wurde die Pfeil Taste nach oben gedrckt 
key_force.x = -1; / es wurde die Pfeil Taste nach unten gedrckt 
verstehen Sie? Diese Variable wird mit 10 multiplizieret - desto hher die Zahl (hier 10) desto schneller ist der Player! Noch nicht verstanden? gucken Sie sich folgendes Besipiel an: 


dist.x = 0 * 10; 
dist.x = 1 * 10; 
dist.x = -1 * 10; 
Das sind alle mglichkeiten - je nachdem, welchen Wert key_force.x hat! Mit dem Move Befehl knnen wir den Player dann bewegen! Also in die Verschiedenen Richtungen, die wir mit dist angeben (dist.x = n. vorne oder hinten; dist.y = n. rechts oder links; dist.z = n. oben oder unten). Aber unser Player hat noch das Problem, dass er sich nicht dre drehen kann. Zum drehen knnen wir den pan-Wert benutzten! Etwa so: 


--------------------------------------------------------------------------------
var dist[3]; 
action player1 
{ 
while(1) 
{ 
dist.x = key_force.x * 10; 
dist.y = 0; 
dist.z = 0; 
move(my,dist,nullvector); 
my.pan -= key_force.y * 3; 
wait(1); 
} 
} 
--------------------------------------------------------------------------------

So, dass heit das der pan-Wert entweder mehr, oder weniger wird! Das hngt hier von der Variable key_force.y ab! Diese gibt an, ob eine Pfeiltaste nach links, rechts oder keine von beiden gedrckt ist! Jatzt muss die Camera aber auch noch kommen! Das machen wir am besten mit einer eignen Fucntion. Wir nennen Diese Function mal Cam_Player(). Das einzige, was wir machen mssen ist die Camera-Positionen genau den Positionen des Player zu geben. Das geht so: 


--------------------------------------------------------------------------------
var dist[3]; 
action player1 
{ 
while(1) 
{ 
dist.x = key_force.x * 10; 
dist.y = 0; 
dist.z = 0; 
move(my,dist,nullvector); 
my.pan -= key_force.y * 3; 
Cam_player(); 
wait(1); 
} 
} 
function Cam_player() 
{ 
Camera.x = my.x; 
Camera.y = my.y; 
Camera.z = my.z; 
} 
--------------------------------------------------------------------------------

Hier wird der Camera einfach eine neue Position zugeteilt. Per Camera.x - Camera.y - Camera.z haben wir zugriff auf die Positionen der Camera. Diese stellen wir einfach zum Player (Camera.x = my.x;, ...) . Wenn sie noch fragen haben schicken Sie diese bitte an Kalkschmidtonline@gmx.de. 

Copyright(c) by Thomas Kalkschmidt
Actionen und Functionen 
Hier werde ich ihnen zeigen, was das ist, wie man sie erstellt und sinnvoll einsetzt. 

Functionen sind blcke, in denen Anweisungen stehen. Functionen werden so definiert. 


--------------------------------------------------------------------------------
Function Hallo() 
{ 
Anweisung1; 
Anweisung2; 
... 
} 
--------------------------------------------------------------------------------

Natrlich knnen Sie nicht "Anweisung" schreiben! Die Anweisungen die dort vorkommen, werden dann von oben bis unten einzelnd durchgefhrt! Es gibt eine Ausnahme, mit Goto, die ich Ihnen hier aber nicht zeigen will weil es den Code oft unbersichtlich macht. Functionen kann man auch dazu verwenden, um nicht immer die selben befehle (ab ca. 2 Befehlen lohnt es sich) zu schreiben. anstatt dessen ruft man dann immer eine function auf! Beispiel: 


--------------------------------------------------------------------------------
function a_b_five() 
{ 
a = 5; 
b = 5; 
} 
--------------------------------------------------------------------------------
Die Function a_b_five() gibt den Variabeln "a" und "b" den Wert 5. natrlich muss man die auch noch deklariren, darum geht es aber nicht in diesem Tutorial. Wenn man jetzt 10 mal den Variabeln a und b den Wert 5 zuweisen mchte, muss man lediglich die Function a_b_five() aufrufen. Das geht mit a_b_five();. jetzt haben Sie aus 2 Zeilen sozusagen 1 gemacht. Man kann auch Functionen in Functionen aufrufen, und in diesen Functionen kann man.....! Beispiel: 
--------------------------------------------------------------------------------
function f1() { 
f2(); 
f3(); 
f4(); 
} 
function f2() 
{ 
a=5; 
} 

function f3() 
{ 
a+=5; 
} 

function f4() 
{ 
a*=2; 
} 


--------------------------------------------------------------------------------

So, hier werden in einer Functionen 3 neue Functionen ausgefhrt! In diesen Functionen werden wieder die einzelnen Befehle "abgefahren". Wenn die Function beendet ist wird dann wieder beim Aufruf der Function weitergearbeitet. Fals Sie mitgerechnet haben, "a" hat jetzt den Wert 20(erst 5, dann 5 dazu und zum schluss *2). Achten Sie darauf, das die Functionen immer zwei Klammern "()" am ende haben, Sie knnen in diesem auch noch Parameter machen - das knnen Sie aber alles im Hand- Buch nach lesen! 

Bei Actionen ist es etwas anders. Sie brauchen keine Klammern am ende und werden so definiert: 


--------------------------------------------------------------------------------
action dreh_dich1 
{ 
Anweisung1; 
Anweisung2; 
... 
} 
--------------------------------------------------------------------------------

So sieht dann die Action aus! Es ist ntzlich, hinter den Actions immer Zahlen zu schreiben ( dreh_dich1), dann kann man auch verschiedene Actions mit fast der selben Wirkung gleich benennen (wenn die zahl immer anders ist). Auch in der Action werden die Anweisungen von oben bis unten abgearbeitet. In Actionen werden oft Endlosschleifen genutzt, damit die Entity, der die Action zugewiesen wird auch immer aktiv ist. beispiel: 


--------------------------------------------------------------------------------
action dreh_dich1 
{ 
while(1) //Endlosschleife 
{ 
my.pan += 10;//Entity dreht sich - immer 10 Grad mehr 
wait(1); //damit andere Functionen/Actionen auch nochausgefhrt werden knnen 
} 
} 
--------------------------------------------------------------------------------

So, haben Sie alles verstanden? Wenn nicht schicken Sie Ihre frage an Kalkschmidtonline@gmx.de. 

Copyright(c) by Thomas Kalkschmidt 
